<!DOCTYPE html>



  


<html class="theme-next gemini use-motion" lang="zh-Hans">
<head><meta name="generator" content="Hexo 3.9.0">
  <meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
<meta name="theme-color" content="#222">



  
  
    
    
  <script src="/lib/pace/pace.min.js?v=1.0.2"></script>
  <link href="/lib/pace/pace-theme-minimal.min.css?v=1.0.2" rel="stylesheet">







<meta http-equiv="Cache-Control" content="no-transform">
<meta http-equiv="Cache-Control" content="no-siteapp">
















  
  
  <link href="/lib/fancybox/source/jquery.fancybox.css?v=2.1.5" rel="stylesheet" type="text/css">




  
  
  
  

  
    
    
  

  

  

  

  

  
    
    
    <link href="//fonts.googleapis.com/css?family=Lato:300,300italic,400,400italic,700,700italic&subset=latin,latin-ext" rel="stylesheet" type="text/css">
  






<link href="/lib/font-awesome/css/font-awesome.min.css?v=4.6.2" rel="stylesheet" type="text/css">

<link href="/css/main.css?v=5.1.4" rel="stylesheet" type="text/css">


  <link rel="apple-touch-icon" sizes="180x180" href="/images/180x180a.png?v=5.1.4">


  <link rel="icon" type="image/png" sizes="32x32" href="/images/32x32a.png?v=5.1.4">


  <link rel="icon" type="image/png" sizes="16x16" href="/images/32x32a.png?v=5.1.4">


  <link rel="mask-icon" href="/images/180x180.svg?v=5.1.4" color="#222">


  <link rel="manifest" href="/images/manifest.json">




  <meta name="keywords" content="笔记,C/C++,">





  <link rel="alternate" href="/atom.xml" title="AbelChe's Blog" type="application/atom+xml">






<meta name="description" content="一、从C到C++ C++如何实现I/O？它的优势在哪里？ 1、c++中I/O的概念 在c++中有一个stream，这个类，所有的I/O都以这个“流”为基础，包括我们认识的文件I/O。stream有两个重要的运算符:  a、插入器(&amp;lt;&amp;lt;):向流输入数据。 b、析取器(&amp;gt;&amp;gt;):从流中读取数据。    2、与c语言相比之下的优势 1、最大的好处时完成了对流操作的封装。原来文件操作">
<meta name="keywords" content="笔记,C&#x2F;C++">
<meta property="og:type" content="article">
<meta property="og:title" content="C++复习！！！(课本:谭老爷爷版)">
<meta property="og:url" content="http://AbelChe.com/2018/06/24/c++复习/index.html">
<meta property="og:site_name" content="AbelChe&#39;s Blog">
<meta property="og:description" content="一、从C到C++ C++如何实现I/O？它的优势在哪里？ 1、c++中I/O的概念 在c++中有一个stream，这个类，所有的I/O都以这个“流”为基础，包括我们认识的文件I/O。stream有两个重要的运算符:  a、插入器(&amp;lt;&amp;lt;):向流输入数据。 b、析取器(&amp;gt;&amp;gt;):从流中读取数据。    2、与c语言相比之下的优势 1、最大的好处时完成了对流操作的封装。原来文件操作">
<meta property="og:locale" content="zh-Hans">
<meta property="og:updated_time" content="2019-08-20T07:43:34.752Z">
<meta name="twitter:card" content="summary">
<meta name="twitter:title" content="C++复习！！！(课本:谭老爷爷版)">
<meta name="twitter:description" content="一、从C到C++ C++如何实现I/O？它的优势在哪里？ 1、c++中I/O的概念 在c++中有一个stream，这个类，所有的I/O都以这个“流”为基础，包括我们认识的文件I/O。stream有两个重要的运算符:  a、插入器(&amp;lt;&amp;lt;):向流输入数据。 b、析取器(&amp;gt;&amp;gt;):从流中读取数据。    2、与c语言相比之下的优势 1、最大的好处时完成了对流操作的封装。原来文件操作">



<script type="text/javascript" id="hexo.configurations">
  var NexT = window.NexT || {};
  var CONFIG = {
    root: '/',
    scheme: 'Gemini',
    version: '5.1.4',
    sidebar: {"position":"left","display":"hide","offset":12,"b2t":false,"scrollpercent":true,"onmobile":true},
    fancybox: true,
    tabs: true,
    motion: {"enable":true,"async":false,"transition":{"post_block":"slideLeftIn","post_header":"fadeIn","post_body":"fadeIn","coll_header":"fadeIn","sidebar":"slideDownIn"}},
    duoshuo: {
      userId: '0',
      author: '博主'
    },
    algolia: {
      applicationID: '',
      apiKey: '',
      indexName: '',
      hits: {"per_page":10},
      labels: {"input_placeholder":"Search for Posts","hits_empty":"We didn't find any results for the search: ${query}","hits_stats":"${hits} results found in ${time} ms"}
    }
  };
</script>



  <link rel="canonical" href="http://AbelChe.com/2018/06/24/c++复习/">





  <title>C++复习！！！(课本:谭老爷爷版) | AbelChe's Blog</title>
  








</head>

<body itemscope itemtype="http://schema.org/WebPage" lang="zh-Hans">

  
  
    
  

  <div class="container sidebar-position-left page-post-detail">
    <div class="headband"></div>

    <header id="header" class="header" itemscope itemtype="http://schema.org/WPHeader">
      <div class="header-inner"><div class="site-brand-wrapper">
  <div class="site-meta custom-logo">
    

    <div class="custom-logo-site-title">
      <a href="/" class="brand" rel="start">
        <span class="logo-line-before"><i></i></span>
        <span class="site-title">AbelChe's Blog</span>
        <span class="logo-line-after"><i></i></span>
      </a>
    </div>
      
        <h1 class="site-subtitle" itemprop="description">Youth means limitless possibilities.</h1>
      
  </div>

  <div class="site-nav-toggle">
    <button>
      <span class="btn-bar"></span>
      <span class="btn-bar"></span>
      <span class="btn-bar"></span>
    </button>
  </div>
</div>

<nav class="site-nav">
  

  
    <ul id="menu" class="menu">
      
        
        <li class="menu-item menu-item-home">
          <a href="/" rel="section">
            
              <i class="menu-item-icon fa fa-fw fa-home"></i> <br>
            
            首页
          </a>
        </li>
      
        
        <li class="menu-item menu-item-about">
          <a href="/about/" rel="section">
            
              <i class="menu-item-icon fa fa-fw fa-user"></i> <br>
            
            关于
          </a>
        </li>
      
        
        <li class="menu-item menu-item-tags">
          <a href="/tags/" rel="section">
            
              <i class="menu-item-icon fa fa-fw fa-tags"></i> <br>
            
            标签
          </a>
        </li>
      
        
        <li class="menu-item menu-item-categories">
          <a href="/categories/" rel="section">
            
              <i class="menu-item-icon fa fa-fw fa-th"></i> <br>
            
            分类
          </a>
        </li>
      
        
        <li class="menu-item menu-item-archives">
          <a href="/archives/" rel="section">
            
              <i class="menu-item-icon fa fa-fw fa-archive"></i> <br>
            
            归档
          </a>
        </li>
      
        
        <li class="menu-item menu-item-在线运行">
          <a href="/runcode/" rel="section">
            
              <i class="menu-item-icon fa fa-fw fa-code"></i> <br>
            
            在线运行
          </a>
        </li>
      
        
        <li class="menu-item menu-item-友链">
          <a href="/friends/" rel="section">
            
              <i class="menu-item-icon fa fa-fw fa-at"></i> <br>
            
            友链
          </a>
        </li>
      
        
        <li class="menu-item menu-item-sitemap">
          <a href="/sitemap.xml" rel="section">
            
              <i class="menu-item-icon fa fa-fw fa-sitemap"></i> <br>
            
            站点地图
          </a>
        </li>
      

      
        <li class="menu-item menu-item-search">
          
            <a href="javascript:;" class="popup-trigger">
          
            
              <i class="menu-item-icon fa fa-search fa-fw"></i> <br>
            
            搜索
          </a>
        </li>
      
    </ul>
  

  
    <div class="site-search">
      
  <div class="popup search-popup local-search-popup">
  <div class="local-search-header clearfix">
    <span class="search-icon">
      <i class="fa fa-search"></i>
    </span>
    <span class="popup-btn-close">
      <i class="fa fa-times-circle"></i>
    </span>
    <div class="local-search-input-wrapper">
      <input autocomplete="off" placeholder="搜索..." spellcheck="false" type="text" id="local-search-input">
    </div>
  </div>
  <div id="local-search-result"></div>
</div>



    </div>
  
</nav>

<link rel="manifest" href="/manifest.json">

 </div>
    </header>

    <main id="main" class="main">
      <div class="main-inner">
        <div class="content-wrap">
          <div id="content" class="content">
            

  <div id="posts" class="posts-expand">
    

  

  
  
  

  <article class="post post-type-normal" itemscope itemtype="http://schema.org/Article">
  
  
  
  <div class="post-block">
    <link itemprop="mainEntityOfPage" href="http://AbelChe.com/2018/06/24/c++复习/">

    <span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
      <meta itemprop="name" content="AbelChe">
      <meta itemprop="description" content>
      <meta itemprop="image" content="/uploads/images/head.png">
    </span>

    <span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
      <meta itemprop="name" content="AbelChe's Blog">
    </span>

    
      <header class="post-header">

        
        
          <h2 class="post-title" itemprop="name headline">C++复习！！！(课本:谭老爷爷版)</h2>
        

        <div class="post-meta">
          
          <span class="post-time">
            
              <span class="post-meta-item-icon">
                <i class="fa fa-calendar-o"></i>
              </span>
              
                <span class="post-meta-item-text">发表于</span>
              
              <time title="创建于" itemprop="dateCreated datePublished" datetime="2018-06-24T15:33:00+08:00">
                2018-06-24
              </time>
            

            
              <span class="post-meta-divider">|</span>
            

            
              <span class="post-meta-item-icon">
                <i class="fa fa-calendar-check-o"></i>
              </span>
              
                <span class="post-meta-item-text">更新于&#58;</span>
              
              <time title="更新于" itemprop="dateModified" datetime="2019-08-20T15:43:34+08:00">
                2019-08-20
              </time>
            
          </span>

          
            <span class="post-category">
            
              <span class="post-meta-divider">|</span>
            
              <span class="post-meta-item-icon">
                <i class="fa fa-folder-o"></i>
              </span>
              
                <span class="post-meta-item-text">分类于</span>
              
              
                <span itemprop="about" itemscope itemtype="http://schema.org/Thing">
                  <a href="/categories/Learning/" itemprop="url" rel="index">
                    <span itemprop="name">Learning</span>
                  </a>
                </span>

                
                
              
            </span>
          

          
            
              <span class="post-comments-count">
                <span class="post-meta-divider">|</span>
                <span class="post-meta-item-icon">
                  <i class="fa fa-comment-o"></i>
                </span>
                <a href="/2018/06/24/c++复习/#comments" itemprop="discussionUrl">
                  <span class="post-comments-count valine-comment-count" data-xid="/2018/06/24/c++复习/" itemprop="commentCount"></span>
                </a>
              </span>
            
          

          
          

          
            <span class="post-meta-divider">|</span>
            <span class="page-pv"><i class="fa fa-file-o"></i> 阅读数
            <span class="busuanzi-value" id="busuanzi_value_page_pv"></span>
            </span>
          

          
            <div class="post-wordcount">
              
                
                <span class="post-meta-item-icon">
                  <i class="fa fa-file-word-o"></i>
                </span>
                
                  <span class="post-meta-item-text">字数统计&#58;</span>
                
                <span title="字数统计">
                  5,410 字
                </span>
              

              
                <span class="post-meta-divider">|</span>
              

              
                <span class="post-meta-item-icon">
                  <i class="fa fa-clock-o"></i>
                </span>
                
                  <span class="post-meta-item-text">阅读时长 &asymp;</span>
                
                <span title="阅读时长">
                  19 分钟
                </span>
              
            </div>
          

          

        </div>
      </header>
    

    
    
    
    <div class="post-body" itemprop="articleBody">

      
      

      
        <h3 id="一、从C到C"><a href="#一、从C到C" class="headerlink" title="一、从C到C++"></a><font color="DarkViolet"><center>一、从C到C++</center></font></h3><hr>
<h4 id="C-如何实现I-O？它的优势在哪里？"><a href="#C-如何实现I-O？它的优势在哪里？" class="headerlink" title="C++如何实现I/O？它的优势在哪里？"></a>C++如何实现I/O？它的优势在哪里？</h4><ul>
<li>1、c++中I/O的概念<blockquote>
<p>在c++中有一个<strong>stream</strong>，这个类，所有的I/O都以这个“流”为基础，包括我们认识的文件I/O。stream有两个重要的运算符:</p>
<ul>
<li>a、<strong>插入器(&lt;&lt;)</strong>:向流输入数据。</li>
<li>b、<strong>析取器(&gt;&gt;)</strong>:从流中读取数据。</li>
</ul>
</blockquote>
</li>
<li>2、与c语言相比之下的优势<blockquote>
<p>1、最大的好处时完成了对流操作的<strong>封装</strong>。原来文件操作都是一个个分开的函数，现在的操作都是对象的方法。<br>2、stream适用于设备输入和输出的。fstream是stream的派生类，即文件流(设备对象是文件)，作为文件在c++中的一个抽象对象。</p>
</blockquote>
</li>
</ul>
<hr>
<h4 id="什么是重载函数？如何区分重载函数？"><a href="#什么是重载函数？如何区分重载函数？" class="headerlink" title="什么是重载函数？如何区分重载函数？"></a>什么是重载函数？如何区分重载函数？</h4><ul>
<li>1、什么是重载函数？<blockquote>
<p>c++允许在同一作用域中用同意函数名来定义多个函数，这些函数的参数个数和参数类型不相同，这些同名的函数用来实现不同的功能，这就是<strong>函数的重载</strong>，即一个<strong>函数名多用</strong>。</p>
</blockquote>
</li>
<li>2、区分函数重载<blockquote>
<ul>
<li>1、<strong>函数形参的个数</strong>；</li>
<li>2、<strong>函数形参的类型</strong>；</li>
<li>3、<strong>形参的顺序</strong>；</li>
<li>4、<strong>不能把返回值作为函数重载的条件</strong>，原因是编辑器在编译时不回去判断函数的返回类型，函数只有调用后，编译器才会去验证返回类型，所以返回值类型不能做为函数重载的依据；</li>
<li>5、<strong>常函数const可以作为函数重载的判断依据</strong>，原因:重载[]运算符时，有没有const的区别是:有const只读，没有const读写都可以。</li>
</ul>
</blockquote>
</li>
</ul>
<hr>
<h4 id="什么是函数模板？为什么要使用函数模板？"><a href="#什么是函数模板？为什么要使用函数模板？" class="headerlink" title="什么是函数模板？为什么要使用函数模板？"></a>什么是函数模板？为什么要使用函数模板？</h4><ul>
<li>1、什么是函数模板？<blockquote>
<p>建立一个通用函数，其函数类型和形参不具体指定，用一个虚函数的类型来代表，这个通用的函数就称为<strong>函数模板</strong>。</p>
<blockquote>
<p>例:max函数模板<br> <code>template&lt;typename T&gt;T max(T a, T b, T c) {}</code></p>
</blockquote>
</blockquote>
</li>
<li>2、为什么要使用函数模板？<blockquote>
<p><strong>简化</strong>对同名的知识形参类型不同的函数的定义。</p>
</blockquote>
</li>
</ul>
<hr>
<h4 id="使用带有默认参数的函数时，要注意些什么？"><a href="#使用带有默认参数的函数时，要注意些什么？" class="headerlink" title="使用带有默认参数的函数时，要注意些什么？"></a>使用带有默认参数的函数时，要注意些什么？</h4><ul>
<li><blockquote>
<p>1、如果函数的定义在函数调用之前，则应在函数定义中给出默认值。</p>
</blockquote>
</li>
<li><blockquote>
<p>2、一个函数不能既作为重载函数，又作为有默认参数的函数。</p>
</blockquote>
</li>
</ul>
<hr>
<h4 id="什么是变量的引用？要注意什么？"><a href="#什么是变量的引用？要注意什么？" class="headerlink" title="什么是变量的引用？要注意什么？"></a>什么是变量的引用？要注意什么？</h4><ul>
<li><blockquote>
<p>在c++中，变量的“引用”就是变量的别名，因此，<strong>引用</strong>又称<strong>别名</strong>。<br>建立“引用”的作用是为一个变量再起另一个名字，一边在需要时可以方便、间接地引用该变量。<br>对一个变量的“引用”的所有的操作，实际上都是对其所代表的(原来的)变量的操作。</p>
<blockquote>
<p>例:有一个变量a，想给他起一个别名b</p>
</blockquote>
</blockquote>
<figure class="highlight angelscript"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br></pre></td><td class="code"><pre><span class="line"><span class="built_in">int</span> a;</span><br><span class="line"><span class="built_in">int</span> &amp;b = a;</span><br></pre></td></tr></table></figure>
</li>
<li><blockquote>
<p>ATTENTION:由于引用不是独立的变量，编译系统给它单独分配储存单元，因此，在建立引用时只有声明没有定义，只是声明它和原有某一变量的关系。</p>
</blockquote>
</li>
</ul>
<hr>
<h4 id="为什么要使用inline函数？"><a href="#为什么要使用inline函数？" class="headerlink" title="为什么要使用inline函数？"></a>为什么要使用inline函数？</h4><ul>
<li><blockquote>
<p>为了<strong>提高效率</strong>。</p>
</blockquote>
</li>
<li><blockquote>
<p>调用函数时需要一定的时间，如果有些函数需要频繁使用，则累计所用时间会很长，从而降低程序的执行效率。<br>c++提供一种提高效率的方法，即在编译时，将所调用函数的代码嵌入到主调函数中。这种嵌入到主调函数中的函数称为<strong>内联函数</strong>。</p>
</blockquote>
</li>
</ul>
<hr>
<h4 id="作用域限定符“-”的作用是什么"><a href="#作用域限定符“-”的作用是什么" class="headerlink" title="作用域限定符“::”的作用是什么"></a>作用域限定符“::”的作用是什么</h4><ul>
<li><blockquote>
<p>在c++中，不同作用域内声明的变量可以同名，当局部变量和全局变量同名时，在局部变量中引用全局变量用到作用域限定符“<strong>::</strong>”。<br>当全局变量和局部变量名字相同，重载时，就规定:<br>用 “<strong>:: + 全局变量名</strong>” 来称呼全局变量。</p>
</blockquote>
</li>
</ul>
<hr>
<h3 id="二、类和对象"><a href="#二、类和对象" class="headerlink" title="二、类和对象"></a><font color="DarkViolet"><center>二、类和对象</center></font></h3><hr>
<p><strong><font size="6" color="OrangeRed"><center>程序 = 对象 + 对象</center></font></strong><br><strong><font size="6" color="OrangeRed"><center>对象 = 算法 + 数据结构</center></font></strong></p>
<hr>
<h4 id="什么是类？什么是对象？什么是抽象？什么是类的声明、类的定义？"><a href="#什么是类？什么是对象？什么是抽象？什么是类的声明、类的定义？" class="headerlink" title="什么是类？什么是对象？什么是抽象？什么是类的声明、类的定义？"></a>什么是类？什么是对象？什么是抽象？什么是类的声明、类的定义？</h4><ul>
<li><p><strong>对象</strong>:</p>
<blockquote>
<p>客观世界中任何一个事物都可以看成一个<strong>对象</strong>(object)。</p>
</blockquote>
</li>
<li><p><strong>类</strong>:</p>
<blockquote>
<p>类是所有面向对象语言的共同特征，所有面向对象的语言都提供了这种类型。</p>
</blockquote>
</li>
<li><p><strong>抽象</strong>:</p>
<blockquote>
<p><strong>类</strong>是<strong>对象</strong>的抽象，而对象是类的具体实例。</p>
</blockquote>
</li>
<li><p><strong>数据抽象</strong>: </p>
<blockquote>
<p>只向外界提供关键信息，并隐藏其后台的实现细节，即只表现必要的信息而不呈现细节。数据抽象是一种依赖于接口和实现分离的编程(设计)技术。</p>
</blockquote>
</li>
<li><p><strong>类的声明</strong>:</p>
<blockquote>
</blockquote>
<figure class="highlight css"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br></pre></td><td class="code"><pre><span class="line"><span class="selector-tag">class</span> 类名 &#123;</span><br><span class="line"><span class="attribute">private</span>:</span><br><span class="line">	私有的数据和成员函数;</span><br><span class="line"><span class="attribute">public</span>:</span><br><span class="line">	公用的数据和成员函数;</span><br><span class="line"><span class="attribute">protected</span>:</span><br><span class="line">	受保护的数据和成员函数;</span><br><span class="line">&#125;;</span><br></pre></td></tr></table></figure>
</li>
<li><p><strong>类的定义</strong>:</p>
<blockquote>
</blockquote>
<figure class="highlight kotlin"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br><span class="line">19</span><br><span class="line">20</span><br><span class="line">21</span><br><span class="line">22</span><br><span class="line">23</span><br><span class="line">24</span><br><span class="line">25</span><br></pre></td><td class="code"><pre><span class="line"><span class="comment">//1、先声明，后定义:</span></span><br><span class="line"><span class="comment">//(1)、</span></span><br><span class="line"><span class="class"><span class="keyword">class</span> 类名 对象名1,<span class="type">对象名2</span>,<span class="type">...;</span></span></span><br><span class="line"><span class="comment">//(2)、</span></span><br><span class="line">类名 对象名<span class="number">1</span>,对象名<span class="number">2</span>,...;</span><br><span class="line"></span><br><span class="line"><span class="comment">//2、声明同时定义:</span></span><br><span class="line"><span class="class"><span class="keyword">class</span> 类名 </span>&#123;</span><br><span class="line"><span class="keyword">private</span>:</span><br><span class="line">	私有的数据和成员函数;</span><br><span class="line"><span class="keyword">public</span>:</span><br><span class="line">	公用的数据和成员函数;</span><br><span class="line"><span class="keyword">protected</span>:</span><br><span class="line">	受保护的数据和成员函数;</span><br><span class="line">&#125;对象名<span class="number">1</span>,对象名<span class="number">2</span>,...;</span><br><span class="line"></span><br><span class="line"><span class="comment">//3、不出现类名直接定义对象(非常 不建议 使用):</span></span><br><span class="line"><span class="class"><span class="keyword">class</span> </span>&#123;</span><br><span class="line"><span class="keyword">private</span>:</span><br><span class="line">	私有的数据和成员函数;</span><br><span class="line"><span class="keyword">public</span>:</span><br><span class="line">	公用的数据和成员函数;</span><br><span class="line"><span class="keyword">protected</span>:</span><br><span class="line">	受保护的数据和成员函数;</span><br><span class="line">&#125;对象名<span class="number">1</span>,对象名<span class="number">2</span>,...;</span><br></pre></td></tr></table></figure>

</li>
</ul>
<hr>
<h4 id="c-中有哪些权限限定符？各起什么作用？"><a href="#c-中有哪些权限限定符？各起什么作用？" class="headerlink" title="c++中有哪些权限限定符？各起什么作用？"></a>c++中有哪些权限限定符？各起什么作用？</h4><ul>
<li><strong>private</strong><blockquote>
<p>private将成员声明为<strong>私有成员</strong>，只能被<strong>本类中的成员函数</strong>引用，类外不能调用(友元类除外)。</p>
</blockquote>
</li>
<li><strong>public</strong><blockquote>
<p>public将成员声明为<strong>公有成员</strong>，既可以被<strong>本类成员函数</strong>所引用，也可以被<strong>类的作用域内的其他函数</strong>所引用。</p>
</blockquote>
</li>
<li><strong>protected</strong><blockquote>
<p>protected将成员声明为<strong>受保护成员</strong>，不能被类外访问，但是可以被<strong>派生类的成员函数</strong>访问。</p>
</blockquote>
</li>
</ul>
<hr>
<h4 id="什么是类的封装？封装的原则是什么？"><a href="#什么是类的封装？封装的原则是什么？" class="headerlink" title="什么是类的封装？封装的原则是什么？"></a>什么是类的封装？封装的原则是什么？</h4><ul>
<li><strong>1、什么是封装？</strong><blockquote>
<p><strong>封装</strong>可以隐藏实现细节，使代码模块化。<br><strong>封装</strong>是把过程和数据包围起来，对数据的访问只能通过已定义的界面。<br>在面向对象编程上可理解为:把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。</p>
</blockquote>
</li>
<li><strong>2、封装的原则是什么？</strong><blockquote>
<p><strong>简化用户接口，隐藏实现细节，这个是封装的根本目的。</strong><br>封装的难点在于如何设计接口。<br><strong>其一</strong>:必须保证接口是功能的全集，即接口能够覆盖所有需求。不能完成必要功能的封装是没有意义的。<br><strong>其二</strong>:尽量使接口是最小冗余的。这是为了简化类使用者的学习和使用，难用的接口是最容易让人遗忘的。冗余接口的存在是被允许的，但必须保证冗余接口是有效的。也就是说，增加冗余接口会带来很大的好处，比如性能的飞升。<br><strong>其三</strong>:要保证接口是稳定的，将接口和实现分离，并将实现隐藏，就是为了能保护类使用者在类的实现细节改变的情况下，不必随时修改。一旦接口被公布，永远也不要改变它。</p>
</blockquote>
</li>
</ul>
<hr>
<h4 id="同一个类所定义的不同对象在调用同一个成员函数时，调用的是同一段代码吗？通过什么来区分各自的数据？"><a href="#同一个类所定义的不同对象在调用同一个成员函数时，调用的是同一段代码吗？通过什么来区分各自的数据？" class="headerlink" title="同一个类所定义的不同对象在调用同一个成员函数时，调用的是同一段代码吗？通过什么来区分各自的数据？"></a>同一个类所定义的不同对象在调用同一个成员函数时，调用的是同一段代码吗？通过什么来区分各自的数据？</h4><ul>
<li><blockquote>
<p><strong>是同一段代码</strong>。</p>
</blockquote>
</li>
<li><blockquote>
<p><strong>通过this指针</strong>:每一个成员函数中都包括这个指针的名字是固定的，称为this。<strong>它是指向对象的指针，他的值是当前被调用的成员函数所在的对象的起始地址</strong>。<br>例:</p>
</blockquote>
<figure class="highlight arduino"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br></pre></td><td class="code"><pre><span class="line"><span class="keyword">int</span> Box::volume()&#123;</span><br><span class="line">    <span class="keyword">return</span> (<span class="built_in">height</span> * <span class="built_in">width</span> * length);</span><br><span class="line">&#125;</span><br><span class="line"><span class="comment">//C++把它处理为:</span></span><br><span class="line"><span class="keyword">int</span> Box::volume(Box * <span class="keyword">this</span>)&#123;</span><br><span class="line">    <span class="keyword">return</span> (<span class="keyword">this</span>-&gt;<span class="built_in">height</span> * <span class="keyword">this</span>-&gt;<span class="built_in">width</span> * <span class="keyword">this</span>-&gt;length);</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>

</li>
</ul>
<hr>
<h4 id="类的成员函数和普通全局函数在形式上有什么区别？在本质上有什么区别？"><a href="#类的成员函数和普通全局函数在形式上有什么区别？在本质上有什么区别？" class="headerlink" title="类的成员函数和普通全局函数在形式上有什么区别？在本质上有什么区别？"></a>类的成员函数和普通全局函数在形式上有什么区别？在本质上有什么区别？</h4><ul>
<li><blockquote>
<p><strong>区别</strong>1:静态成员函数实际上是一个全局函数,不依赖一个类的对象. 而属于类，不创建对象也可调用，静态成员函数没有this指针。普通成员函数依赖一个类的对象,也就是它有一个隐藏的调用参数(this)指针,必须指向一个类的对象。</p>
</blockquote>
</li>
<li><blockquote>
<p><strong>区别2</strong>:静态函数只能访问类中的静态成员变量；</p>
</blockquote>
</li>
<li><blockquote>
<p><strong>区别3</strong>:如果成员函数想作为回调函数来使用，如创建线程等，一般只能将它定义为静态成员函数才行。</p>
</blockquote>
</li>
</ul>
<hr>
<h3 id="三、类和对象的进一步讨论"><a href="#三、类和对象的进一步讨论" class="headerlink" title="三、类和对象的进一步讨论"></a><font color="DarkViolet"><center>三、类和对象的进一步讨论</center></font></h3><hr>
<h4 id="构造函数、析构函数的英文单词是什么？"><a href="#构造函数、析构函数的英文单词是什么？" class="headerlink" title="构造函数、析构函数的英文单词是什么？"></a>构造函数、析构函数的英文单词是什么？</h4><ul>
<li><blockquote>
<p><strong>构造函数——constructor</strong></p>
</blockquote>
</li>
<li><blockquote>
<p><strong>析构函数——destructor</strong></p>
</blockquote>
</li>
</ul>
<hr>
<h4 id="构造函数的特点是什么？析构函数的特点是什么？"><a href="#构造函数的特点是什么？析构函数的特点是什么？" class="headerlink" title="构造函数的特点是什么？析构函数的特点是什么？"></a>构造函数的特点是什么？析构函数的特点是什么？</h4><ul>
<li><blockquote>
<p>c++提供构造函数，来处理对象的初始化。构造函数是一种<strong>特殊的成员函数</strong>，与其他成员函数不同，不需要用户来调用它，而是在建立对象时自动执行。构造函数只是起初始化值的作用，但实例化一个对象的时候，可以通过实例去传递参数，从主函数传递到其他的函数里面，这样就使其他的函数里面有值了。规则，只要你一实例化对象，系统自动回调用一个构造函数，就算不写，编译器也自动调用一次。</p>
</blockquote>
</li>
<li><blockquote>
<p>析构函数与构造函数同名，但该函数前面加~。析构函数<strong>没有参数</strong>，也<strong>没有返回值</strong>，而且<strong>不能重载</strong>，在<strong>一个类中只能有一个析构函数</strong>。当<strong>撤销对象时，编译器也会自动调用析构函数</strong>。<strong>每一个类必须有一个析构函数</strong>，用户可以自定义析构函数，也可以是编译器自动生成默认的析构函数。一般析构函数定义为类的公有成员。</p>
</blockquote>
</li>
</ul>
<hr>
<h4 id="构造函数、析构函数的执行顺序是什么？"><a href="#构造函数、析构函数的执行顺序是什么？" class="headerlink" title="构造函数、析构函数的执行顺序是什么？"></a>构造函数、析构函数的执行顺序是什么？</h4><ul>
<li><blockquote>
<p><strong>先构造的先执行析构</strong>。</p>
</blockquote>
</li>
</ul>
<hr>
<h4 id="在C语言中，我们说main-函数是程序的入口，是最先被调用的函数，在C-中情况是这样吗？如果不是请说明原因，并举出实例。"><a href="#在C语言中，我们说main-函数是程序的入口，是最先被调用的函数，在C-中情况是这样吗？如果不是请说明原因，并举出实例。" class="headerlink" title="在C语言中，我们说main()函数是程序的入口，是最先被调用的函数，在C++中情况是这样吗？如果不是请说明原因，并举出实例。"></a>在C语言中，我们说main()函数是程序的入口，是最先被调用的函数，在C++中情况是这样吗？如果不是请说明原因，并举出实例。</h4><ul>
<li><blockquote>
<p><strong>c++中不是这样</strong>。</p>
</blockquote>
</li>
<li><blockquote>
<p>因为存在构造数据类型的定义对象定义，且对象为全局对象的话，则该类对象所属的构造类型的构造函数在main()函数之前执行。</p>
</blockquote>
</li>
</ul>
<hr>
<h4 id="const关键字"><a href="#const关键字" class="headerlink" title="const关键字"></a>const关键字</h4><center><strong><font color="Crimson" size="6">const在c++中要尽可能的使用</font></strong></center>

<style>
table th:first-of-type {
width:30%;
}
</style>

<table>
<thead>
<tr>
<th align="center">形式</th>
<th align="center">含义</th>
</tr>
</thead>
<tbody><tr>
<td align="center"><code>Time const t1;</code></td>
<td align="center">t1是常对象，其值在任何情况下都不能改变</td>
</tr>
<tr>
<td align="center"><code>void Time::fun()const;</code></td>
<td align="center">fun是Time类中的成员函数，可以引用，但不能修改本类中的成员数据</td>
</tr>
<tr>
<td align="center"><code>Time * const p;</code></td>
<td align="center">p是指向time类对象的常指针变量，p的值(p的指向)不能改变</td>
</tr>
<tr>
<td align="center"><code>const Time * p;</code></td>
<td align="center">p是指向Time类常对象的指针变量，p指向的类对象的值不能通过p来改变</td>
</tr>
<tr>
<td align="center"><code>const Time &amp;t1 = t;</code></td>
<td align="center">t1是Time类对象t的引用，二者指向同一储存空间，t的值不能改变</td>
</tr>
<tr>
<td align="center">- &gt; const的作用是:<strong>数据的保护</strong></td>
<td align="center"></td>
</tr>
<tr>
<td align="center">- 常成员变量</td>
<td align="center"></td>
</tr>
</tbody></table>
<blockquote>
<p>类的常成员变量是用const关键字声明的成员变量，<strong>其值不可改变</strong>，它的<strong>初始值必须通过构造函数的初始化列表方式完成</strong>。一般将一个类中不可改变的值声明为常成员变量。<br>但const成员变量有一个缺点:该类的所有对象都会const成员变量，而不是整个类共用一个。这种情况下，const常和static一起使用。</p>
<ul>
<li>const成员函数<br>const成员函数语法为:<code>int Obj::Func const;</code>这表明成员函数Func const是个常成员函数，它的作用是表明<strong>只能引用类中的数据成员</strong>，而<strong>不能修改类中的数据成员</strong>。</li>
<li>常对象<br>语法为:<code>const obj o(10);</code> 或 <code>obj const o(10);</code><br>用const声明的对象为常对象，常对象必须初始化，<br>如果一个对象被声明为const对象，则该对象的数据成员不可修改。即const对象不能调用该对象的非const成员函数。</li>
<li>指向const数据的指针<br>定义指针时，在指针的类型<strong>前面</strong>加上const表明该指针指向的对象是个常量。</li>
<li>const指针<br>在定义指针时，在指针的<strong>前面</strong>加上const表明该指针是一个常量，它必须被初始化。</li>
<li>const在参数中的使用<br>const在参数类型为指针或引用时经常被使用，这表明这个指针或引用所指向的数据不允许被修改，这样就保证了在被调函数中不能因为误操作而改变了主调函数中的值。</li>
</ul>
</blockquote>
<hr>
<h4 id="初始化列表的语法是怎样的？"><a href="#初始化列表的语法是怎样的？" class="headerlink" title="初始化列表的语法是怎样的？"></a>初始化列表的语法是怎样的？</h4><ul>
<li>如下:<figure class="highlight reasonml"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br></pre></td><td class="code"><pre><span class="line">类名::构造函数名(<span class="literal">[参数表]</span>)<span class="literal">[:成员初始化表]</span>&#123;</span><br><span class="line"><span class="literal">[构造函数体]</span></span><br><span class="line">&#125;</span><br><span class="line"><span class="comment">//例:</span></span><br><span class="line"><span class="keyword">class</span> Student&#123;</span><br><span class="line">public:</span><br><span class="line">    <span class="constructor">Student(<span class="params">int</span> <span class="params">n</span>, <span class="params">char</span> <span class="params">s</span>, <span class="params">nam</span>[])</span>:num(n), sex(s)&#123;</span><br><span class="line">        strcpy(name, nam);</span><br><span class="line">    &#125;</span><br><span class="line"><span class="keyword">private</span>:</span><br><span class="line">    <span class="built_in">int</span> num;</span><br><span class="line">    <span class="built_in">char</span> sex;</span><br><span class="line">    <span class="built_in">int</span> name<span class="literal">[<span class="number">20</span>]</span>;</span><br><span class="line">&#125;;</span><br></pre></td></tr></table></figure>

</li>
</ul>
<hr>
<h4 id="在C-中为什么使用new-delete，而不是malloc-free-来来动态创建对象？如何使用new-delete来动态创建数组？"><a href="#在C-中为什么使用new-delete，而不是malloc-free-来来动态创建对象？如何使用new-delete来动态创建数组？" class="headerlink" title="在C++中为什么使用new/delete，而不是malloc()/free()来来动态创建对象？如何使用new/delete来动态创建数组？"></a>在C++中为什么使用new/delete，而不是malloc()/free()来来动态创建对象？如何使用new/delete来动态创建数组？</h4><ul>
<li><blockquote>
<p>c语言中使用库函数malloc()和free()来动态申请和释放内存空间，但是存在两个问题:<br>1、分配的大小需人为计算;<br>2、只分配空间，而不涉及类型。<br>c++使用了运算符new和delete来取代malloc()和free()函数。<strong>动态分配/释放内存</strong>。</p>
</blockquote>
</li>
<li>例:动态创建一维数组<figure class="highlight cpp"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br></pre></td><td class="code"><pre><span class="line"><span class="meta">#<span class="meta-keyword">include</span> <span class="meta-string">&lt;iostream&gt;</span></span></span><br><span class="line"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="built_in">std</span>;</span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span>&#123;</span><br><span class="line">    <span class="keyword">int</span> n;</span><br><span class="line">    <span class="built_in">cin</span> &gt;&gt; n;</span><br><span class="line">    <span class="comment">//动态分配一维数组</span></span><br><span class="line">    <span class="keyword">int</span> *arr = <span class="keyword">new</span> <span class="keyword">int</span> [n];</span><br><span class="line">    <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i &lt; n; i++)</span><br><span class="line">  	  <span class="built_in">cin</span> &gt;&gt; arr[i];</span><br><span class="line">    <span class="keyword">for</span>(<span class="keyword">int</span> i = <span class="number">0</span>; i &lt; n; i++)</span><br><span class="line">  	  <span class="built_in">cout</span> &lt;&lt; arr[i] &lt;&lt; <span class="string">" "</span>;</span><br><span class="line">    <span class="comment">//释放arr数组</span></span><br><span class="line">    <span class="keyword">delete</span>[] arr;</span><br><span class="line">    <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>

</li>
</ul>
<hr>
<h4 id="什么是对象的复制？什么是对象的赋值？"><a href="#什么是对象的复制？什么是对象的赋值？" class="headerlink" title="什么是对象的复制？什么是对象的赋值？"></a>什么是对象的复制？什么是对象的赋值？</h4><ul>
<li>对象的赋值<blockquote>
<p>一般形式:<code>对象名1 = 对象名2；</code><br><strong>对象的赋值只是用赋值号右边的对象的数据覆盖了赋值号左边的的对象的数据成员</strong>。因此必须使用有默认参数值的构造函数，以保证左值能被初始化。</p>
</blockquote>
</li>
<li>对象的复制<blockquote>
<p>一般形式:<code>类名 对象2(对象1)；</code> 或 `类名 对象2 = 对象1;<br>例:</p>
</blockquote>
<figure class="highlight cpp"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br><span class="line">5</span><br><span class="line">6</span><br><span class="line">7</span><br><span class="line">8</span><br><span class="line">9</span><br><span class="line">10</span><br><span class="line">11</span><br><span class="line">12</span><br><span class="line">13</span><br><span class="line">14</span><br><span class="line">15</span><br><span class="line">16</span><br><span class="line">17</span><br><span class="line">18</span><br></pre></td><td class="code"><pre><span class="line"><span class="class"><span class="keyword">class</span> <span class="title">Student</span>&#123;</span></span><br><span class="line">pubilc:</span><br><span class="line">    Student ()&#123;m_strName=<span class="string">"Jim"</span>;&#125;</span><br><span class="line">    <span class="comment">/*</span></span><br><span class="line"><span class="comment">    默认的拷贝构造函数:</span></span><br><span class="line"><span class="comment">    Student (const Student &amp;stu)&#123;&#125;</span></span><br><span class="line"><span class="comment">    */</span></span><br><span class="line">    Student(<span class="keyword">const</span> Student &amp;stu)&#123;m_strName = stu.m_strName;&#125;</span><br><span class="line">    <span class="comment">//显性定义的拷贝构造函数</span></span><br><span class="line"><span class="keyword">private</span>:</span><br><span class="line">    <span class="built_in">string</span> m_strName;</span><br><span class="line">&#125;;</span><br><span class="line"><span class="function"><span class="keyword">int</span> <span class="title">main</span><span class="params">()</span></span>&#123;</span><br><span class="line">    Student stu1;</span><br><span class="line">    Student stu2 = stu1;</span><br><span class="line">    <span class="function">Student <span class="title">stu3</span><span class="params">(stu1)</span></span>;</span><br><span class="line">    <span class="keyword">return</span> <span class="number">0</span>;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>

</li>
</ul>
<hr>
<h4 id="什么是深拷贝-浅拷贝？-拷贝构造函数的语法如何？"><a href="#什么是深拷贝-浅拷贝？-拷贝构造函数的语法如何？" class="headerlink" title="什么是深拷贝/浅拷贝？ 拷贝构造函数的语法如何？"></a>什么是深拷贝/浅拷贝？ 拷贝构造函数的语法如何？</h4><ul>
<li>浅拷贝<blockquote>
<p>对象拷贝时，仅仅是简单的值拷贝，这称为“浅拷贝”，这是系统默认的拷贝模式，不需要编程实现。</p>
</blockquote>
</li>
<li>深拷贝<blockquote>
<p>对象拷贝时，对堆中的数据编程进行拷贝，这称为“深拷贝”，这种拷贝模式需要编程实现。</p>
</blockquote>
</li>
<li><strong>拷贝构造函数</strong><blockquote>
<p>拷贝构造函数中只有哟个参数，为本类对象的一个引用，并通常使用const修饰。<br>语法:</p>
</blockquote>
<figure class="highlight livescript"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line">obj(<span class="keyword">const</span> obj &amp;o)&#123;</span><br><span class="line">    <span class="literal">no</span> = o.<span class="literal">no</span>;</span><br><span class="line">    cout &lt;&lt; <span class="string">"copy constructor"</span> &lt;&lt; <span class="literal">no</span> &lt;&lt; endl;</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>

</li>
</ul>
<hr>
<h4 id="static数据成员和static成员函数的特点是什么？static成员函数有什么限制？static数据成员如何初始化？"><a href="#static数据成员和static成员函数的特点是什么？static成员函数有什么限制？static数据成员如何初始化？" class="headerlink" title="static数据成员和static成员函数的特点是什么？static成员函数有什么限制？static数据成员如何初始化？"></a>static数据成员和static成员函数的特点是什么？static成员函数有什么限制？static数据成员如何初始化？</h4><ul>
<li><blockquote>
<p><strong>static数据成员</strong>拥有一块单独的储存区(不再类对象内部)，不管该类创造了多少个对象。所有该类的对象共享这块区域，这就为这些类之间提供了一种相互通信的方法，并且它不会占据对象的储存空间。他的名字是属于类的(例:Circle::PI)，这样可以很大程度上解决全局数据的名字冲突问题。它是有权限控制的，也就是说他可以是private的。</p>
</blockquote>
</li>
<li><blockquote>
<p>除了数据成员能定义为static的，成员函数也可以定义为static的。与static数据成员一样，static成员函数也是属于类的，而不是属于对象的。static成员函数是属于类的，所以它没有this指针，不创建对象就可以被调用。它的这个特点决定了<strong>static成员函数只能访问类中的static数据成员和static成员函数</strong>。与类的static数据成员一样，<strong>推荐使用类方式引用类的static成员函数</strong>。</p>
</blockquote>
</li>
<li><blockquote>
<p>在类内提供的仅仅是static数据成员的声明(编译器没有给它分配空间)，而不是定义，所以不能使用构造函数对其进行初始化，<strong>static数据成员的初始化必须在类外完成</strong>。static数据成员在使用时，既可以使用对象方式引用，也可以使用类方式引用，通常使用类方式引用，以表明它是一个static数据成员。</p>
</blockquote>
</li>
</ul>
<hr>
<h4 id="为什么要使用友元？哪些内容可以作为类的友元？我们对友元的态度是什么？"><a href="#为什么要使用友元？哪些内容可以作为类的友元？我们对友元的态度是什么？" class="headerlink" title="为什么要使用友元？哪些内容可以作为类的友元？我们对友元的态度是什么？"></a>为什么要使用友元？哪些内容可以作为类的友元？我们对友元的态度是什么？</h4><ul>
<li><blockquote>
<p>友元机制可以带来一些便利。</p>
</blockquote>
</li>
<li><blockquote>
<p>友元可以实现在类的外部访问一个类的<strong>private成员</strong></p>
</blockquote>
</li>
<li><blockquote>
<p>友元机制虽然可以带来一些便利，但是它严重破坏了程序的封装性，也有影响程序的可读性，所以要<strong>慎重使用友元</strong>。</p>
</blockquote>
</li>
</ul>
<hr>
<h3 id="四、运算符重载"><a href="#四、运算符重载" class="headerlink" title="四、运算符重载"></a><font color="DarkViolet"><center>四、运算符重载</center></font></h3><hr>
<h4 id="在C-中运算符被当作什么处理？如何重载运算符？重载运算符有什么好处？需要注意哪些问题？运算符重载一般以哪两种方式出现？该如何选择？"><a href="#在C-中运算符被当作什么处理？如何重载运算符？重载运算符有什么好处？需要注意哪些问题？运算符重载一般以哪两种方式出现？该如何选择？" class="headerlink" title="在C++中运算符被当作什么处理？如何重载运算符？重载运算符有什么好处？需要注意哪些问题？运算符重载一般以哪两种方式出现？该如何选择？"></a><a href="https://blog.csdn.net/u013982161/article/details/52830143" target="_blank" rel="noopener">在C++中运算符被当作什么处理？如何重载运算符？重载运算符有什么好处？需要注意哪些问题？运算符重载一般以哪两种方式出现？该如何选择？</a></h4><hr>
<h3 id="五、继承和派生"><a href="#五、继承和派生" class="headerlink" title="五、继承和派生"></a><font color="DarkViolet"><center>五、继承和派生</center></font></h3><hr>
<h4 id="继承的单词是什么？语法如何？继承方式限定符有哪些？作用分别是什么？"><a href="#继承的单词是什么？语法如何？继承方式限定符有哪些？作用分别是什么？" class="headerlink" title="继承的单词是什么？语法如何？继承方式限定符有哪些？作用分别是什么？"></a>继承的单词是什么？语法如何？继承方式限定符有哪些？作用分别是什么？</h4><ul>
<li><blockquote>
<p><strong>继承——inheritance</strong>。继承就是在已有类的基础上建立一个新类的过程。其中已经存在的类称为基类(base class)，新建立的类称为派生类(derived class)，从基类产生派生类的过程称为派生。</p>
</blockquote>
</li>
<li><blockquote>
<p><strong>继承的语法</strong>:</p>
  <figure class="highlight kotlin"><table><tr><td class="gutter"><pre><span class="line">1</span><br><span class="line">2</span><br><span class="line">3</span><br><span class="line">4</span><br></pre></td><td class="code"><pre><span class="line"><span class="class"><span class="keyword">class</span> 派生类名: <span class="type">[继承方式] 基类名 &#123;</span></span></span><br><span class="line">    <span class="comment">//继承方式不写默认是private。</span></span><br><span class="line">    派生类新增加的成员</span><br><span class="line">&#125;</span><br></pre></td></tr></table></figure>
</blockquote>
</li>
<li><blockquote>
<p><strong>继承方式限定</strong>:<br>  <strong>private</strong>:基类的公有成员和保护成员在派生类中保持原有访问属性，其私有成员仍为基类私有。<br>  <strong>public</strong>:积累的公有成员和保护成员在派生类中成了私有成员，其私有成员仍为基类私有。<br>  <strong>protected</strong>:积累的公有成员和保护成员在派生类中成了保护成员，其私有成员仍为基类私有。</p>
</blockquote>
</li>
</ul>
<hr>
<h4 id="继承发生时，在派生类的对象内部会有一个基类的对象，这个基类对象的初始化是由基类的构造函数完成的，那么如何在派生类中有选择的调用基类的非默认构造函数呢？"><a href="#继承发生时，在派生类的对象内部会有一个基类的对象，这个基类对象的初始化是由基类的构造函数完成的，那么如何在派生类中有选择的调用基类的非默认构造函数呢？" class="headerlink" title="继承发生时，在派生类的对象内部会有一个基类的对象，这个基类对象的初始化是由基类的构造函数完成的，那么如何在派生类中有选择的调用基类的非默认构造函数呢？"></a>继承发生时，在派生类的对象内部会有一个基类的对象，这个基类对象的初始化是由基类的构造函数完成的，那么如何在派生类中有选择的调用基类的非默认构造函数呢？</h4><ul>
<li><blockquote>
</blockquote>
</li>
</ul>
<hr>
<h4 id="继承发生时，派生类是否全部接收基类的成员？如果不是哪些成员不被继承。"><a href="#继承发生时，派生类是否全部接收基类的成员？如果不是哪些成员不被继承。" class="headerlink" title="继承发生时，派生类是否全部接收基类的成员？如果不是哪些成员不被继承。"></a>继承发生时，派生类是否全部接收基类的成员？如果不是哪些成员不被继承。</h4><ul>
<li><blockquote>
<p><strong>派生类要无条件的接收基类中的全部成员</strong>。</p>
</blockquote>
</li>
<li><blockquote>
<p>派生类尽管拥有基类的所有的成员，但是<strong>派生类不能访问基类private的成员</strong>。</p>
</blockquote>
</li>
</ul>
<hr>
<p><font size="5" color="Orangered"><strong><center>派生类从基类中继承的成员在不同的继承方式下的访问权限</center></strong></font></p>
<center>![](https://hdwena.sn.files.1drv.com/y4mhMErgzce0OjomgHTh_UJda9Dha1RoPDfRdvbQdw6z2vtiulYKo4l89RC8FBLsUEN7NHN0I8-RcpUKyyim93Gtb1ckcUYLDxQnIAAQvIIK2HAC0YOZshMXXpz2INa5S_lq88gY0d1bk8i6uIlXBWPip1S_e2rKV7CueKh7Ykj4faOsqIkFOO4XqpMoESSDg7r3I6OMZTvX4FfIH7X5mQawA?width=944&height=299&cropmode=none)</center>

<hr>
<h4 id="组合-子对象-的作用是什么？如何有选择的调用对象成员的非默认构造函数？组合和继承都可以实现代码重用，那么什么时候选择组合，什么时候选择继承？"><a href="#组合-子对象-的作用是什么？如何有选择的调用对象成员的非默认构造函数？组合和继承都可以实现代码重用，那么什么时候选择组合，什么时候选择继承？" class="headerlink" title="组合(子对象)的作用是什么？如何有选择的调用对象成员的非默认构造函数？组合和继承都可以实现代码重用，那么什么时候选择组合，什么时候选择继承？"></a>组合(子对象)的作用是什么？如何有选择的调用对象成员的非默认构造函数？组合和继承都可以实现代码重用，那么什么时候选择组合，什么时候选择继承？</h4><ul>
<li><blockquote>
<p>子对象就是类对象中内嵌的对象。当派生类中存在子对象时，派生类的构造函数需要依次完成以下3部分:<br>1、先调用基类构造函数初始化基类数据。<br>2、再调用子对象的构造函数初始化子对象中的数据。<br>3、最后初始化自己的数据成员。</p>
</blockquote>
</li>
</ul>
<hr>
<h4 id="当继承和组合都存在时，构造和析构的顺序如何？"><a href="#当继承和组合都存在时，构造和析构的顺序如何？" class="headerlink" title="当继承和组合都存在时，构造和析构的顺序如何？"></a>当继承和组合都存在时，构造和析构的顺序如何？</h4><hr>
<h4 id="哪些地方必须使用初始化列表？"><a href="#哪些地方必须使用初始化列表？" class="headerlink" title="哪些地方必须使用初始化列表？"></a>哪些地方必须使用初始化列表？</h4><hr>
<h4 id="什么是overriding、overload？什么是upcasting？"><a href="#什么是overriding、overload？什么是upcasting？" class="headerlink" title="什么是overriding、overload？什么是upcasting？"></a>什么是overriding、overload？什么是upcasting？</h4><hr>
<h4 id="多继承会带来什么问题？如何解决这个问题？对待多继承的态度是什么？"><a href="#多继承会带来什么问题？如何解决这个问题？对待多继承的态度是什么？" class="headerlink" title="多继承会带来什么问题？如何解决这个问题？对待多继承的态度是什么？"></a>多继承会带来什么问题？如何解决这个问题？对待多继承的态度是什么？</h4><hr>
<h3 id="六、多态性和虚函数"><a href="#六、多态性和虚函数" class="headerlink" title="六、多态性和虚函数"></a><font color="DarkViolet"><center>六、多态性和虚函数</center></font></h3><hr>
<h4 id="什么是多态性？英文单词是什么？它能给我们程序设计带来什么好处？"><a href="#什么是多态性？英文单词是什么？它能给我们程序设计带来什么好处？" class="headerlink" title="什么是多态性？英文单词是什么？它能给我们程序设计带来什么好处？"></a>什么是多态性？英文单词是什么？它能给我们程序设计带来什么好处？</h4><hr>
<h4 id="如何实现多态性？"><a href="#如何实现多态性？" class="headerlink" title="如何实现多态性？"></a>如何实现多态性？</h4><hr>
<h4 id="虚函数是如何实现的-考试不会考-？"><a href="#虚函数是如何实现的-考试不会考-？" class="headerlink" title="虚函数是如何实现的(考试不会考)？"></a>虚函数是如何实现的(考试不会考)？</h4><hr>
<h4 id="动态-静态绑定-binding、联编-的优缺点各是什么？"><a href="#动态-静态绑定-binding、联编-的优缺点各是什么？" class="headerlink" title="动态/静态绑定(binding、联编)的优缺点各是什么？"></a>动态/静态绑定(binding、联编)的优缺点各是什么？</h4><hr>
<h4 id="什么是纯虚函数？什么是抽象类？其意义各自是什么？"><a href="#什么是纯虚函数？什么是抽象类？其意义各自是什么？" class="headerlink" title="什么是纯虚函数？什么是抽象类？其意义各自是什么？"></a>什么是纯虚函数？什么是抽象类？其意义各自是什么？</h4><hr>
<h3 id="七、输入输出流"><a href="#七、输入输出流" class="headerlink" title="七、输入输出流"></a><font color="DarkViolet"><center>七、输入输出流</center></font></h3><hr>
<h4 id="C-I-O的优势在哪-和前面第一章的类似-？"><a href="#C-I-O的优势在哪-和前面第一章的类似-？" class="headerlink" title="C++I/O的优势在哪(和前面第一章的类似)？"></a>C++I/O的优势在哪(和前面第一章的类似)？</h4><hr>
<h4 id="标准输出流有哪些？它们之间的区别是什么？如何控制格式的输出？标准的输入流是什么？"><a href="#标准输出流有哪些？它们之间的区别是什么？如何控制格式的输出？标准的输入流是什么？" class="headerlink" title="标准输出流有哪些？它们之间的区别是什么？如何控制格式的输出？标准的输入流是什么？"></a>标准输出流有哪些？它们之间的区别是什么？如何控制格式的输出？标准的输入流是什么？</h4><hr>
<h4 id="如何使用文件流进行输入-输出-步骤-？"><a href="#如何使用文件流进行输入-输出-步骤-？" class="headerlink" title="如何使用文件流进行输入/输出(步骤)？"></a>如何使用文件流进行输入/输出(步骤)？</h4><hr>
<h4 id="什么是字符串流？它有什么用好处？"><a href="#什么是字符串流？它有什么用好处？" class="headerlink" title="什么是字符串流？它有什么用好处？"></a>什么是字符串流？它有什么用好处？</h4><hr>
<h3 id="八、C-工具"><a href="#八、C-工具" class="headerlink" title="八、C++工具"></a><font color="DarkViolet"><center>八、C++工具</center></font></h3><hr>
<h4 id="实现异常的三个关键字是什么？大致的作用是什么？"><a href="#实现异常的三个关键字是什么？大致的作用是什么？" class="headerlink" title="实现异常的三个关键字是什么？大致的作用是什么？"></a>实现异常的三个关键字是什么？大致的作用是什么？</h4><hr>

      
    </div>
    
    
    

    
      <div>
        <div id="wechat_subscriber" style="display: block; padding: 10px 0; margin: 20px auto; width: 100%; text-align: center">
    <img id="wechat_subscriber_qcode" src="/uploads/images/wechatQR_2.JPG" alt="AbelChe wechat" style="width: 200px; max-width: 100%;">
    <div>扫码加微信</div>
</div>

      </div>
    

    
      <div>
        <div style="padding: 10px 0; margin: 20px auto; width: 90%; text-align: center;">
  <div>Donate here!!!</div>
  <button id="rewardButton" disable="enable" onclick="var qr = document.getElementById('QR'); if (qr.style.display === 'none') {qr.style.display='block';} else {qr.style.display='none'}">
    <span>打赏</span>
  </button>
  <div id="QR" style="display: none;">

    
      <div id="wechat" style="display: inline-block">
        <img id="wechat_qr" src="/images/wechatpay.png" alt="AbelChe 微信支付">
        <p>微信支付</p>
      </div>
    

    
      <div id="alipay" style="display: inline-block">
        <img id="alipay_qr" src="/images/alipay.png" alt="AbelChe 支付宝">
        <p>支付宝</p>
      </div>
    

    

  </div>
</div>

      </div>
    

    
      <div>
        <ul class="post-copyright">
  <li class="post-copyright-author">
    <strong>本文作者：</strong>
    AbelChe
  </li>
  <li class="post-copyright-link">
    <strong>本文链接：</strong>
    <a href="http://AbelChe.com/2018/06/24/c++复习/" title="C++复习！！！(课本:谭老爷爷版)">http://AbelChe.com/2018/06/24/c++复习/</a>
  </li>
  <li class="post-copyright-license">
    <strong>版权声明： </strong>
    本博客所有文章除特别声明外，均采用 <a href="https://creativecommons.org/licenses/by-nc-sa/3.0/" rel="external nofollow" target="_blank">CC BY-NC-SA 3.0</a> 许可协议。转载请注明出处！
  </li>
</ul>

      </div>
    

    <footer class="post-footer">
      
        <div class="post-tags">
          
            <a href="/tags/笔记/" rel="tag"># 笔记</a>
          
            <a href="/tags/C-C/" rel="tag"># C/C++</a>
          
        </div>
      

      
      
      

      
        <div class="post-nav">
          <div class="post-nav-next post-nav-item">
            
          </div>

          <span class="post-nav-divider"></span>

          <div class="post-nav-prev post-nav-item">
            
              <a href="/2018/06/29/Hexo常用命令/" rel="prev" title="Hexo常用命令">
                Hexo常用命令 <i class="fa fa-chevron-right"></i>
              </a>
            
          </div>
        </div>
      

      
      
    </footer>
  </div>
  
  
  
  </article>



    <div class="post-spread">
      
    </div>
  </div>


          </div>
          


          

  
    <div class="comments" id="comments">
    </div>
  



        </div>
        
          
  
  <div class="sidebar-toggle">
    <div class="sidebar-toggle-line-wrap">
      <span class="sidebar-toggle-line sidebar-toggle-line-first"></span>
      <span class="sidebar-toggle-line sidebar-toggle-line-middle"></span>
      <span class="sidebar-toggle-line sidebar-toggle-line-last"></span>
    </div>
  </div>

  <aside id="sidebar" class="sidebar">
    
      <div id="sidebar-dimmer"></div>
    
    <div class="sidebar-inner">

      

      
        <ul class="sidebar-nav motion-element">
          <li class="sidebar-nav-toc sidebar-nav-active" data-target="post-toc-wrap">
            文章目录
          </li>
          <li class="sidebar-nav-overview" data-target="site-overview-wrap">
            站点概览
          </li>
        </ul>
      

      <section class="site-overview-wrap sidebar-panel">
        <div class="site-overview">
          <div class="site-author motion-element" itemprop="author" itemscope itemtype="http://schema.org/Person">
            
              <a href="/"><img class="site-author-image" itemprop="image" src="/uploads/images/head.png" alt="AbelChe"></a>
            
              <a href="/"><p class="site-author-name" itemprop="name">AbelChe</p></a>
              <p class="site-description motion-element" itemprop="description"></p>
          </div>

          <nav class="site-state motion-element">

            
              <div class="site-state-item site-state-posts">
              
                <a href="/archives/">
              
                  <span class="site-state-item-count">65</span>
                  <span class="site-state-item-name">日志</span>
                </a>
              </div>
            

            
              
              
              <div class="site-state-item site-state-categories">
                <a href="/categories/index.html">
                  <span class="site-state-item-count">13</span>
                  <span class="site-state-item-name">分类</span>
                </a>
              </div>
            

            
              
              
              <div class="site-state-item site-state-tags">
                <a href="/tags/index.html">
                  <span class="site-state-item-count">81</span>
                  <span class="site-state-item-name">标签</span>
                </a>
              </div>
            

          </nav>

          
            <div class="feed-link motion-element">
              <a href="/atom.xml" rel="alternate">
                <i class="fa fa-rss"></i>
                RSS
              </a>
            </div>
          

          
            <div class="links-of-author motion-element">
                
                  <span class="links-of-author-item">
                    <a href="https://github.com/AbelChe" target="_blank" title="GitHub">
                      
                        <i class="fa fa-fw fa-github"></i>GitHub</a>
                  </span>
                
                  <span class="links-of-author-item">
                    <a href="https://coding.net/u/AbelChe" target="_blank" title="Coding">
                      
                        <i class="fa fa-fw fa-bullseye"></i>Coding</a>
                  </span>
                
                  <span class="links-of-author-item">
                    <a href="https://gitee.com/abelche" target="_blank" title="Gitee">
                      
                        <i class="fa fa-fw fa-codepen"></i>Gitee</a>
                  </span>
                
                  <span class="links-of-author-item">
                    <a href="https://www.aliyun.com" target="_blank" title="Aliyun">
                      
                        <i class="fa fa-fw fa-cloud"></i>Aliyun</a>
                  </span>
                
                  <span class="links-of-author-item">
                    <a href="https://mail.qq.com" target="_blank" title="QQ_mail">
                      
                        <i class="fa fa-fw fa-envelope"></i>QQ_mail</a>
                  </span>
                
                  <span class="links-of-author-item">
                    <a href="http://mail.google.com/mail/" target="_blank" title="Gmail">
                      
                        <i class="fa fa-fw fa-google"></i>Gmail</a>
                  </span>
                
                  <span class="links-of-author-item">
                    <a href="https://twitter.com/AbelChe7" target="_blank" title="Twitter">
                      
                        <i class="fa fa-fw fa-twitter"></i>Twitter</a>
                  </span>
                
            </div>
          

          
          
            <div class="cc-license motion-element" itemprop="license">
              <a href="https://creativecommons.org/licenses/by-nc-sa/4.0/" class="cc-opacity" target="_blank">
                <img src="/images/cc-by-nc-sa.svg" alt="Creative Commons">
              </a>
            </div>
          

          
          
            <div class="links-of-blogroll motion-element links-of-blogroll-inline">
              <div class="links-of-blogroll-title">
                <i class="fa  fa-fw fa-link"></i>
                LINKS
              </div>
              <ul class="links-of-blogroll-list">
                
                  <li class="links-of-blogroll-item">
                    <a href="https://www.baidu.com" title="Baidu" target="_blank">Baidu</a>
                  </li>
                
                  <li class="links-of-blogroll-item">
                    <a href="https://www.google.com" title="Google" target="_blank">Google</a>
                  </li>
                
                  <li class="links-of-blogroll-item">
                    <a href="https://www.csdn.net" title="CSDN" target="_blank">CSDN</a>
                  </li>
                
                  <li class="links-of-blogroll-item">
                    <a href="https://www.bilibili.com" title="Bilibili" target="_blank">Bilibili</a>
                  </li>
                
                  <li class="links-of-blogroll-item">
                    <a href="https://www.taobao.com" title="Taobao" target="_blank">Taobao</a>
                  </li>
                
                  <li class="links-of-blogroll-item">
                    <a href="https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000" title="Python Learning" target="_blank">Python Learning</a>
                  </li>
                
              </ul>
            </div>
          

          

        </div>
      </section>

      
      <!--noindex-->
        <section class="post-toc-wrap motion-element sidebar-panel sidebar-panel-active">
          <div class="post-toc">

            
              
            

            
              <div class="post-toc-content"><ol class="nav"><li class="nav-item nav-level-3"><a class="nav-link" href="#一、从C到C"><span class="nav-number">1.</span> <span class="nav-text">一、从C到C++</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#C-如何实现I-O？它的优势在哪里？"><span class="nav-number">1.1.</span> <span class="nav-text">C++如何实现I/O？它的优势在哪里？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#什么是重载函数？如何区分重载函数？"><span class="nav-number">1.2.</span> <span class="nav-text">什么是重载函数？如何区分重载函数？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#什么是函数模板？为什么要使用函数模板？"><span class="nav-number">1.3.</span> <span class="nav-text">什么是函数模板？为什么要使用函数模板？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#使用带有默认参数的函数时，要注意些什么？"><span class="nav-number">1.4.</span> <span class="nav-text">使用带有默认参数的函数时，要注意些什么？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#什么是变量的引用？要注意什么？"><span class="nav-number">1.5.</span> <span class="nav-text">什么是变量的引用？要注意什么？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#为什么要使用inline函数？"><span class="nav-number">1.6.</span> <span class="nav-text">为什么要使用inline函数？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#作用域限定符“-”的作用是什么"><span class="nav-number">1.7.</span> <span class="nav-text">作用域限定符“::”的作用是什么</span></a></li></ol></li><li class="nav-item nav-level-3"><a class="nav-link" href="#二、类和对象"><span class="nav-number">2.</span> <span class="nav-text">二、类和对象</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#什么是类？什么是对象？什么是抽象？什么是类的声明、类的定义？"><span class="nav-number">2.1.</span> <span class="nav-text">什么是类？什么是对象？什么是抽象？什么是类的声明、类的定义？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#c-中有哪些权限限定符？各起什么作用？"><span class="nav-number">2.2.</span> <span class="nav-text">c++中有哪些权限限定符？各起什么作用？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#什么是类的封装？封装的原则是什么？"><span class="nav-number">2.3.</span> <span class="nav-text">什么是类的封装？封装的原则是什么？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#同一个类所定义的不同对象在调用同一个成员函数时，调用的是同一段代码吗？通过什么来区分各自的数据？"><span class="nav-number">2.4.</span> <span class="nav-text">同一个类所定义的不同对象在调用同一个成员函数时，调用的是同一段代码吗？通过什么来区分各自的数据？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#类的成员函数和普通全局函数在形式上有什么区别？在本质上有什么区别？"><span class="nav-number">2.5.</span> <span class="nav-text">类的成员函数和普通全局函数在形式上有什么区别？在本质上有什么区别？</span></a></li></ol></li><li class="nav-item nav-level-3"><a class="nav-link" href="#三、类和对象的进一步讨论"><span class="nav-number">3.</span> <span class="nav-text">三、类和对象的进一步讨论</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#构造函数、析构函数的英文单词是什么？"><span class="nav-number">3.1.</span> <span class="nav-text">构造函数、析构函数的英文单词是什么？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#构造函数的特点是什么？析构函数的特点是什么？"><span class="nav-number">3.2.</span> <span class="nav-text">构造函数的特点是什么？析构函数的特点是什么？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#构造函数、析构函数的执行顺序是什么？"><span class="nav-number">3.3.</span> <span class="nav-text">构造函数、析构函数的执行顺序是什么？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#在C语言中，我们说main-函数是程序的入口，是最先被调用的函数，在C-中情况是这样吗？如果不是请说明原因，并举出实例。"><span class="nav-number">3.4.</span> <span class="nav-text">在C语言中，我们说main()函数是程序的入口，是最先被调用的函数，在C++中情况是这样吗？如果不是请说明原因，并举出实例。</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#const关键字"><span class="nav-number">3.5.</span> <span class="nav-text">const关键字</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#初始化列表的语法是怎样的？"><span class="nav-number">3.6.</span> <span class="nav-text">初始化列表的语法是怎样的？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#在C-中为什么使用new-delete，而不是malloc-free-来来动态创建对象？如何使用new-delete来动态创建数组？"><span class="nav-number">3.7.</span> <span class="nav-text">在C++中为什么使用new/delete，而不是malloc()/free()来来动态创建对象？如何使用new/delete来动态创建数组？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#什么是对象的复制？什么是对象的赋值？"><span class="nav-number">3.8.</span> <span class="nav-text">什么是对象的复制？什么是对象的赋值？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#什么是深拷贝-浅拷贝？-拷贝构造函数的语法如何？"><span class="nav-number">3.9.</span> <span class="nav-text">什么是深拷贝/浅拷贝？ 拷贝构造函数的语法如何？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#static数据成员和static成员函数的特点是什么？static成员函数有什么限制？static数据成员如何初始化？"><span class="nav-number">3.10.</span> <span class="nav-text">static数据成员和static成员函数的特点是什么？static成员函数有什么限制？static数据成员如何初始化？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#为什么要使用友元？哪些内容可以作为类的友元？我们对友元的态度是什么？"><span class="nav-number">3.11.</span> <span class="nav-text">为什么要使用友元？哪些内容可以作为类的友元？我们对友元的态度是什么？</span></a></li></ol></li><li class="nav-item nav-level-3"><a class="nav-link" href="#四、运算符重载"><span class="nav-number">4.</span> <span class="nav-text">四、运算符重载</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#在C-中运算符被当作什么处理？如何重载运算符？重载运算符有什么好处？需要注意哪些问题？运算符重载一般以哪两种方式出现？该如何选择？"><span class="nav-number">4.1.</span> <span class="nav-text">在C++中运算符被当作什么处理？如何重载运算符？重载运算符有什么好处？需要注意哪些问题？运算符重载一般以哪两种方式出现？该如何选择？</span></a></li></ol></li><li class="nav-item nav-level-3"><a class="nav-link" href="#五、继承和派生"><span class="nav-number">5.</span> <span class="nav-text">五、继承和派生</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#继承的单词是什么？语法如何？继承方式限定符有哪些？作用分别是什么？"><span class="nav-number">5.1.</span> <span class="nav-text">继承的单词是什么？语法如何？继承方式限定符有哪些？作用分别是什么？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#继承发生时，在派生类的对象内部会有一个基类的对象，这个基类对象的初始化是由基类的构造函数完成的，那么如何在派生类中有选择的调用基类的非默认构造函数呢？"><span class="nav-number">5.2.</span> <span class="nav-text">继承发生时，在派生类的对象内部会有一个基类的对象，这个基类对象的初始化是由基类的构造函数完成的，那么如何在派生类中有选择的调用基类的非默认构造函数呢？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#继承发生时，派生类是否全部接收基类的成员？如果不是哪些成员不被继承。"><span class="nav-number">5.3.</span> <span class="nav-text">继承发生时，派生类是否全部接收基类的成员？如果不是哪些成员不被继承。</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#组合-子对象-的作用是什么？如何有选择的调用对象成员的非默认构造函数？组合和继承都可以实现代码重用，那么什么时候选择组合，什么时候选择继承？"><span class="nav-number">5.4.</span> <span class="nav-text">组合(子对象)的作用是什么？如何有选择的调用对象成员的非默认构造函数？组合和继承都可以实现代码重用，那么什么时候选择组合，什么时候选择继承？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#当继承和组合都存在时，构造和析构的顺序如何？"><span class="nav-number">5.5.</span> <span class="nav-text">当继承和组合都存在时，构造和析构的顺序如何？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#哪些地方必须使用初始化列表？"><span class="nav-number">5.6.</span> <span class="nav-text">哪些地方必须使用初始化列表？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#什么是overriding、overload？什么是upcasting？"><span class="nav-number">5.7.</span> <span class="nav-text">什么是overriding、overload？什么是upcasting？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#多继承会带来什么问题？如何解决这个问题？对待多继承的态度是什么？"><span class="nav-number">5.8.</span> <span class="nav-text">多继承会带来什么问题？如何解决这个问题？对待多继承的态度是什么？</span></a></li></ol></li><li class="nav-item nav-level-3"><a class="nav-link" href="#六、多态性和虚函数"><span class="nav-number">6.</span> <span class="nav-text">六、多态性和虚函数</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#什么是多态性？英文单词是什么？它能给我们程序设计带来什么好处？"><span class="nav-number">6.1.</span> <span class="nav-text">什么是多态性？英文单词是什么？它能给我们程序设计带来什么好处？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#如何实现多态性？"><span class="nav-number">6.2.</span> <span class="nav-text">如何实现多态性？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#虚函数是如何实现的-考试不会考-？"><span class="nav-number">6.3.</span> <span class="nav-text">虚函数是如何实现的(考试不会考)？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#动态-静态绑定-binding、联编-的优缺点各是什么？"><span class="nav-number">6.4.</span> <span class="nav-text">动态/静态绑定(binding、联编)的优缺点各是什么？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#什么是纯虚函数？什么是抽象类？其意义各自是什么？"><span class="nav-number">6.5.</span> <span class="nav-text">什么是纯虚函数？什么是抽象类？其意义各自是什么？</span></a></li></ol></li><li class="nav-item nav-level-3"><a class="nav-link" href="#七、输入输出流"><span class="nav-number">7.</span> <span class="nav-text">七、输入输出流</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#C-I-O的优势在哪-和前面第一章的类似-？"><span class="nav-number">7.1.</span> <span class="nav-text">C++I/O的优势在哪(和前面第一章的类似)？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#标准输出流有哪些？它们之间的区别是什么？如何控制格式的输出？标准的输入流是什么？"><span class="nav-number">7.2.</span> <span class="nav-text">标准输出流有哪些？它们之间的区别是什么？如何控制格式的输出？标准的输入流是什么？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#如何使用文件流进行输入-输出-步骤-？"><span class="nav-number">7.3.</span> <span class="nav-text">如何使用文件流进行输入/输出(步骤)？</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#什么是字符串流？它有什么用好处？"><span class="nav-number">7.4.</span> <span class="nav-text">什么是字符串流？它有什么用好处？</span></a></li></ol></li><li class="nav-item nav-level-3"><a class="nav-link" href="#八、C-工具"><span class="nav-number">8.</span> <span class="nav-text">八、C++工具</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#实现异常的三个关键字是什么？大致的作用是什么？"><span class="nav-number">8.1.</span> <span class="nav-text">实现异常的三个关键字是什么？大致的作用是什么？</span></a></li></ol></li></ol></div>
            

          </div>
        </section>
      <!--/noindex-->
      

      

    </div>
  </aside>


        
      </div>
    </main>

    <footer id="footer" class="footer">
      <div class="footer-inner">
        <div class="copyright">&copy; 2018 &mdash; <span itemprop="copyrightYear">2020</span>
  <span class="with-love">
    <i class="fa fa-user"></i>
  </span>
  <span class="author" itemprop="copyrightHolder">AbelChe</span>

  
    <span class="post-meta-divider">|</span>
    <span class="post-meta-item-icon">
      <i class="fa fa-area-chart"></i>
    </span>
    
      <span class="post-meta-item-text">Site words total count&#58;</span>
    
    <span title="Site words total count">43.8k</span>
  
</div>


<!--
  <div class="powered-by">由 <a class="theme-link" target="_blank" href="https://hexo.io">Hexo</a> 强力驱动</div>
-->








        
<div class="busuanzi-count">
  <script async src="https://busuanzi.ibruce.info/busuanzi/2.3/busuanzi.pure.mini.js"></script>

  
    <span class="site-uv">
      <i class="fa fa-user"></i> 访问人数
      <span class="busuanzi-value" id="busuanzi_value_site_uv"></span>
      
    </span>
  

  
    <span class="site-pv">
      <i class="fa fa-eye"></i> 总访问量
      <span class="busuanzi-value" id="busuanzi_value_site_pv"></span>
      次
    </span>
  
</div>








        
      </div>
    </footer>

    
      <div class="back-to-top">
        <i class="fa fa-arrow-up"></i>
        
          <span id="scrollpercent"><span>0</span>%</span>
        
      </div>
    

    
      <div id="needsharebutton-float">
        <span class="btn">
          <i class="fa fa-share-alt" aria-hidden="true"></i>
        </span>
      </div>
    

  </div>

  

<script type="text/javascript">
  if (Object.prototype.toString.call(window.Promise) !== '[object Function]') {
    window.Promise = null;
  }
</script>









  












  
  
    <script type="text/javascript" src="/lib/jquery/index.js?v=2.1.3"></script>
  

  
  
    <script type="text/javascript" src="/lib/fastclick/lib/fastclick.min.js?v=1.0.6"></script>
  

  
  
    <script type="text/javascript" src="/lib/jquery_lazyload/jquery.lazyload.js?v=1.9.7"></script>
  

  
  
    <script type="text/javascript" src="/lib/velocity/velocity.min.js?v=1.2.1"></script>
  

  
  
    <script type="text/javascript" src="/lib/velocity/velocity.ui.min.js?v=1.2.1"></script>
  

  
  
    <script type="text/javascript" src="/lib/fancybox/source/jquery.fancybox.pack.js?v=2.1.5"></script>
  


  


  <script type="text/javascript" src="/js/src/utils.js?v=5.1.4"></script>

  <script type="text/javascript" src="/js/src/motion.js?v=5.1.4"></script>



  
  


  <script type="text/javascript" src="/js/src/affix.js?v=5.1.4"></script>

  <script type="text/javascript" src="/js/src/schemes/pisces.js?v=5.1.4"></script>



  
  <script type="text/javascript" src="/js/src/scrollspy.js?v=5.1.4"></script>
<script type="text/javascript" src="/js/src/post-details.js?v=5.1.4"></script>



  


  <script type="text/javascript" src="/js/src/bootstrap.js?v=5.1.4"></script>



  


  




	





  





  










  <script src="//cdn1.lncld.net/static/js/3.0.4/av-min.js"></script>
  <script src="//unpkg.com/valine/dist/Valine.min.js"></script>
  
  <script type="text/javascript">
    var GUEST = ['nick','mail','link'];
    var guest = 'nick,mail,link';
    guest = guest.split(',').filter(item=>{
      return GUEST.indexOf(item)>-1;
    });
    new Valine({
        el: '#comments' ,
        verify: false,
        notify: false,
        appId: '3dNwvfMcT2yQEr3TkP1gFUbT-gzGzoHsz',
        appKey: 'bjkjOibLdLJcGGrHkTXWeXpA',
        placeholder: 'Just go go',
        avatar:'mm',
        guest_info:guest,
        pageSize:'10' || 10,
    });
  </script>



  

  <script type="text/javascript">
    // Popup Window;
    var isfetched = false;
    var isXml = true;
    // Search DB path;
    var search_path = "search.xml";
    if (search_path.length === 0) {
      search_path = "search.xml";
    } else if (/json$/i.test(search_path)) {
      isXml = false;
    }
    var path = "/" + search_path;
    // monitor main search box;

    var onPopupClose = function (e) {
      $('.popup').hide();
      $('#local-search-input').val('');
      $('.search-result-list').remove();
      $('#no-result').remove();
      $(".local-search-pop-overlay").remove();
      $('body').css('overflow', '');
    }

    function proceedsearch() {
      $("body")
        .append('<div class="search-popup-overlay local-search-pop-overlay"></div>')
        .css('overflow', 'hidden');
      $('.search-popup-overlay').click(onPopupClose);
      $('.popup').toggle();
      var $localSearchInput = $('#local-search-input');
      $localSearchInput.attr("autocapitalize", "none");
      $localSearchInput.attr("autocorrect", "off");
      $localSearchInput.focus();
    }

    // search function;
    var searchFunc = function(path, search_id, content_id) {
      'use strict';

      // start loading animation
      $("body")
        .append('<div class="search-popup-overlay local-search-pop-overlay">' +
          '<div id="search-loading-icon">' +
          '<i class="fa fa-spinner fa-pulse fa-5x fa-fw"></i>' +
          '</div>' +
          '</div>')
        .css('overflow', 'hidden');
      $("#search-loading-icon").css('margin', '20% auto 0 auto').css('text-align', 'center');

      $.ajax({
        url: path,
        dataType: isXml ? "xml" : "json",
        async: true,
        success: function(res) {
          // get the contents from search data
          isfetched = true;
          $('.popup').detach().appendTo('.header-inner');
          var datas = isXml ? $("entry", res).map(function() {
            return {
              title: $("title", this).text(),
              content: $("content",this).text(),
              url: $("url" , this).text()
            };
          }).get() : res;
          var input = document.getElementById(search_id);
          var resultContent = document.getElementById(content_id);
          var inputEventFunction = function() {
            var searchText = input.value.trim().toLowerCase();
            var keywords = searchText.split(/[\s\-]+/);
            if (keywords.length > 1) {
              keywords.push(searchText);
            }
            var resultItems = [];
            if (searchText.length > 0) {
              // perform local searching
              datas.forEach(function(data) {
                var isMatch = false;
                var hitCount = 0;
                var searchTextCount = 0;
                var title = data.title.trim();
                var titleInLowerCase = title.toLowerCase();
                var content = data.content.trim().replace(/<[^>]+>/g,"");
                var contentInLowerCase = content.toLowerCase();
                var articleUrl = decodeURIComponent(data.url);
                var indexOfTitle = [];
                var indexOfContent = [];
                // only match articles with not empty titles
                if(title != '') {
                  keywords.forEach(function(keyword) {
                    function getIndexByWord(word, text, caseSensitive) {
                      var wordLen = word.length;
                      if (wordLen === 0) {
                        return [];
                      }
                      var startPosition = 0, position = [], index = [];
                      if (!caseSensitive) {
                        text = text.toLowerCase();
                        word = word.toLowerCase();
                      }
                      while ((position = text.indexOf(word, startPosition)) > -1) {
                        index.push({position: position, word: word});
                        startPosition = position + wordLen;
                      }
                      return index;
                    }

                    indexOfTitle = indexOfTitle.concat(getIndexByWord(keyword, titleInLowerCase, false));
                    indexOfContent = indexOfContent.concat(getIndexByWord(keyword, contentInLowerCase, false));
                  });
                  if (indexOfTitle.length > 0 || indexOfContent.length > 0) {
                    isMatch = true;
                    hitCount = indexOfTitle.length + indexOfContent.length;
                  }
                }

                // show search results

                if (isMatch) {
                  // sort index by position of keyword

                  [indexOfTitle, indexOfContent].forEach(function (index) {
                    index.sort(function (itemLeft, itemRight) {
                      if (itemRight.position !== itemLeft.position) {
                        return itemRight.position - itemLeft.position;
                      } else {
                        return itemLeft.word.length - itemRight.word.length;
                      }
                    });
                  });

                  // merge hits into slices

                  function mergeIntoSlice(text, start, end, index) {
                    var item = index[index.length - 1];
                    var position = item.position;
                    var word = item.word;
                    var hits = [];
                    var searchTextCountInSlice = 0;
                    while (position + word.length <= end && index.length != 0) {
                      if (word === searchText) {
                        searchTextCountInSlice++;
                      }
                      hits.push({position: position, length: word.length});
                      var wordEnd = position + word.length;

                      // move to next position of hit

                      index.pop();
                      while (index.length != 0) {
                        item = index[index.length - 1];
                        position = item.position;
                        word = item.word;
                        if (wordEnd > position) {
                          index.pop();
                        } else {
                          break;
                        }
                      }
                    }
                    searchTextCount += searchTextCountInSlice;
                    return {
                      hits: hits,
                      start: start,
                      end: end,
                      searchTextCount: searchTextCountInSlice
                    };
                  }

                  var slicesOfTitle = [];
                  if (indexOfTitle.length != 0) {
                    slicesOfTitle.push(mergeIntoSlice(title, 0, title.length, indexOfTitle));
                  }

                  var slicesOfContent = [];
                  while (indexOfContent.length != 0) {
                    var item = indexOfContent[indexOfContent.length - 1];
                    var position = item.position;
                    var word = item.word;
                    // cut out 100 characters
                    var start = position - 20;
                    var end = position + 80;
                    if(start < 0){
                      start = 0;
                    }
                    if (end < position + word.length) {
                      end = position + word.length;
                    }
                    if(end > content.length){
                      end = content.length;
                    }
                    slicesOfContent.push(mergeIntoSlice(content, start, end, indexOfContent));
                  }

                  // sort slices in content by search text's count and hits' count

                  slicesOfContent.sort(function (sliceLeft, sliceRight) {
                    if (sliceLeft.searchTextCount !== sliceRight.searchTextCount) {
                      return sliceRight.searchTextCount - sliceLeft.searchTextCount;
                    } else if (sliceLeft.hits.length !== sliceRight.hits.length) {
                      return sliceRight.hits.length - sliceLeft.hits.length;
                    } else {
                      return sliceLeft.start - sliceRight.start;
                    }
                  });

                  // select top N slices in content

                  var upperBound = parseInt('1');
                  if (upperBound >= 0) {
                    slicesOfContent = slicesOfContent.slice(0, upperBound);
                  }

                  // highlight title and content

                  function highlightKeyword(text, slice) {
                    var result = '';
                    var prevEnd = slice.start;
                    slice.hits.forEach(function (hit) {
                      result += text.substring(prevEnd, hit.position);
                      var end = hit.position + hit.length;
                      result += '<b class="search-keyword">' + text.substring(hit.position, end) + '</b>';
                      prevEnd = end;
                    });
                    result += text.substring(prevEnd, slice.end);
                    return result;
                  }

                  var resultItem = '';

                  if (slicesOfTitle.length != 0) {
                    resultItem += "<li><a href='" + articleUrl + "' class='search-result-title'>" + highlightKeyword(title, slicesOfTitle[0]) + "</a>";
                  } else {
                    resultItem += "<li><a href='" + articleUrl + "' class='search-result-title'>" + title + "</a>";
                  }

                  slicesOfContent.forEach(function (slice) {
                    resultItem += "<a href='" + articleUrl + "'>" +
                      "<p class=\"search-result\">" + highlightKeyword(content, slice) +
                      "...</p>" + "</a>";
                  });

                  resultItem += "</li>";
                  resultItems.push({
                    item: resultItem,
                    searchTextCount: searchTextCount,
                    hitCount: hitCount,
                    id: resultItems.length
                  });
                }
              })
            };
            if (keywords.length === 1 && keywords[0] === "") {
              resultContent.innerHTML = '<div id="no-result"><i class="fa fa-search fa-5x" /></div>'
            } else if (resultItems.length === 0) {
              resultContent.innerHTML = '<div id="no-result"><i class="fa fa-frown-o fa-5x" /></div>'
            } else {
              resultItems.sort(function (resultLeft, resultRight) {
                if (resultLeft.searchTextCount !== resultRight.searchTextCount) {
                  return resultRight.searchTextCount - resultLeft.searchTextCount;
                } else if (resultLeft.hitCount !== resultRight.hitCount) {
                  return resultRight.hitCount - resultLeft.hitCount;
                } else {
                  return resultRight.id - resultLeft.id;
                }
              });
              var searchResultList = '<ul class=\"search-result-list\">';
              resultItems.forEach(function (result) {
                searchResultList += result.item;
              })
              searchResultList += "</ul>";
              resultContent.innerHTML = searchResultList;
            }
          }

          if ('auto' === 'auto') {
            input.addEventListener('input', inputEventFunction);
          } else {
            $('.search-icon').click(inputEventFunction);
            input.addEventListener('keypress', function (event) {
              if (event.keyCode === 13) {
                inputEventFunction();
              }
            });
          }

          // remove loading animation
          $(".local-search-pop-overlay").remove();
          $('body').css('overflow', '');

          proceedsearch();
        }
      });
    }

    // handle and trigger popup window;
    $('.popup-trigger').click(function(e) {
      e.stopPropagation();
      if (isfetched === false) {
        searchFunc(path, 'local-search-input', 'local-search-result');
      } else {
        proceedsearch();
      };
    });

    $('.popup-btn-close').click(onPopupClose);
    $('.popup').click(function(e){
      e.stopPropagation();
    });
    $(document).on('keyup', function (event) {
      var shouldDismissSearchPopup = event.which === 27 &&
        $('.search-popup').is(':visible');
      if (shouldDismissSearchPopup) {
        onPopupClose();
      }
    });
  </script>





  

  

  
<script>
(function(){
    var bp = document.createElement('script');
    var curProtocol = window.location.protocol.split(':')[0];
    if (curProtocol === 'https') {
        bp.src = 'https://zz.bdstatic.com/linksubmit/push.js';        
    }
    else {
        bp.src = 'http://push.zhanzhang.baidu.com/push.js';
    }
    var s = document.getElementsByTagName("script")[0];
    s.parentNode.insertBefore(bp, s);
})();
</script>


  
  
  
  <link rel="stylesheet" href="/lib/needsharebutton/needsharebutton.css">

  
  
  <script src="/lib/needsharebutton/needsharebutton.js"></script>

  <script>
    
    
      flOptions = {};
      
          flOptions.iconStyle = "box";
      
          flOptions.boxForm = "horizontal";
      
          flOptions.position = "middleRight";
      
          flOptions.networks = "Weibo,Douban,QQZone,Twitter,Facebook";
      
      new needShareButton('#needsharebutton-float', flOptions);
    
  </script>

  

  

  
  <script type="text/javascript" src="/js/src/js.cookie.js?v=5.1.4"></script>
  <script type="text/javascript" src="/js/src/scroll-cookie.js?v=5.1.4"></script>


  
  <script type="text/javascript" src="/js/src/exturl.js?v=5.1.4"></script>


</body>
</html>
